```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java异常处理与回调机制</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        .code-block {
            background-color: #2d3748;
            color: #f8fafc;
            border-radius: 0.5rem;
            overflow-x: auto;
        }
        .code-block pre {
            margin: 0;
            padding: 1.25rem;
        }
        .hover-scale {
            transition: transform 0.2s ease-in-out;
        }
        .hover-scale:hover {
            transform: translateY(-4px);
        }
        .card-shadow {
            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
        }
        .card-shadow:hover {
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .highlight {
            position: relative;
        }
        .highlight:after {
            content: '';
            position: absolute;
            bottom: 0;
            left: 0;
            width: 100%;
            height: 30%;
            background-color: rgba(102, 126, 234, 0.2);
            z-index: -1;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 md:py-32 px-4">
        <div class="max-w-5xl mx-auto text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6">Java异常处理与回调机制</h1>
            <p class="text-xl md:text-2xl opacity-90 mb-8">构建健壮系统的关键技术与最佳实践</p>
            <div class="flex justify-center space-x-4">
                <a href="#exception" class="bg-white text-indigo-700 hover:bg-gray-100 px-6 py-3 rounded-lg font-medium transition-colors duration-200">异常处理</a>
                <a href="#callback" class="bg-indigo-700 hover:bg-indigo-800 text-white px-6 py-3 rounded-lg font-medium transition-colors duration-200">回调机制</a>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="max-w-5xl mx-auto px-4 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <p class="text-xl text-gray-700 leading-relaxed">
                在现代软件开发中，异常处理和回调机制是非常重要的部分，尤其在并发编程和分布式系统中，合理地处理异常与回调可以大幅提高系统的健壮性和可维护性。Java作为一门成熟的面向对象编程语言，提供了多种异常处理机制，并且有许多方式可以优雅地实现回调。
            </p>
        </section>

        <!-- Exception Handling -->
        <section id="exception" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="bg-indigo-600 w-2 h-8 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold text-gray-800">异常处理</h2>
            </div>

            <!-- Basic Concepts -->
            <article class="mb-12">
                <h3 class="text-2xl font-semibold text-gray-800 mb-6 flex items-center">
                    <i class="fas fa-circle-info text-indigo-500 mr-3"></i>
                    异常处理的基本概念
                </h3>

                <div class="grid md:grid-cols-2 gap-8">
                    <!-- What is Exception -->
                    <div class="bg-white rounded-xl p-6 card-shadow hover-scale">
                        <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                            <i class="fas fa-triangle-exclamation mr-2"></i>
                            什么是异常？
                        </h4>
                        <p class="text-gray-700">
                            异常（Exception）是程序在运行过程中出现的意外情况。异常通常表示程序的错误或不可预见的行为，例如：网络连接失败、文件读取失败、数据库查询异常等。Java通过<code class="bg-gray-100 px-1 rounded">Throwable</code>类及其子类来表示和处理异常。
                        </p>
                    </div>

                    <!-- Exception Classification -->
                    <div class="bg-white rounded-xl p-6 card-shadow hover-scale">
                        <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                            <i class="fas fa-sitemap mr-2"></i>
                            异常的分类
                        </h4>
                        <p class="text-gray-700 mb-3">Java中的异常分为两类：</p>
                        <ul class="space-y-2">
                            <li class="flex items-start">
                                <span class="bg-indigo-100 text-indigo-800 px-2 py-1 rounded-full text-sm font-medium mr-2">Checked</span>
                                <span>受检查异常（Checked Exception）：这些异常是程序员必须处理的，比如<code class="bg-gray-100 px-1 rounded">IOException</code>、<code class="bg-gray-100 px-1 rounded">SQLException</code>等。</span>
                            </li>
                            <li class="flex items-start">
                                <span class="bg-pink-100 text-pink-800 px-2 py-1 rounded-full text-sm font-medium mr-2">Unchecked</span>
                                <span>未受检查异常（Unchecked Exception）：这些异常通常由程序的逻辑错误引起，比如<code class="bg-gray-100 px-1 rounded">NullPointerException</code>、<code class="bg-gray-100 px-1 rounded">ArrayIndexOutOfBoundsException</code>等。</span>
                            </li>
                        </ul>
                    </div>
                </div>
            </article>

            <!-- Exception Handling Process -->
            <article class="mb-12">
                <h3 class="text-2xl font-semibold text-gray-800 mb-6 flex items-center">
                    <i class="fas fa-code-branch text-indigo-500 mr-3"></i>
                    异常处理的流程
                </h3>
                <p class="text-gray-700 mb-6">
                    在Java中，异常的处理依赖于<code class="bg-gray-100 px-1 rounded">try-catch-finally</code>语句块：
                </p>
                <div class="code-block mb-6">
                    <pre><code class="language-java">try {
    // 可能发生异常的代码
} catch (ExceptionType e) {
    // 异常处理逻辑
} finally {
    // 清理工作，关闭资源等
}</code></pre>
                </div>
                <div class="grid md:grid-cols-3 gap-4 mb-6">
                    <div class="bg-white p-4 rounded-lg border border-gray-200">
                        <h4 class="font-semibold text-indigo-700 mb-2">try块</h4>
                        <p class="text-gray-700">用来包围可能抛出异常的代码</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg border border-gray-200">
                        <h4 class="font-semibold text-indigo-700 mb-2">catch块</h4>
                        <p class="text-gray-700">用来捕获并处理异常</p>
                    </div>
                    <div class="bg-white p-4 rounded-lg border border-gray-200">
                        <h4 class="font-semibold text-indigo-700 mb-2">finally块</h4>
                        <p class="text-gray-700">无论是否发生异常，都会执行的代码块，通常用于释放资源</p>
                    </div>
                </div>
            </article>

            <!-- Graceful Exception Handling -->
            <article class="mb-12">
                <h3 class="text-2xl font-semibold text-gray-800 mb-6 flex items-center">
                    <i class="fas fa-star text-indigo-500 mr-3"></i>
                    优雅地处理异常
                </h3>

                <div class="bg-white rounded-xl p-6 card-shadow mb-8">
                    <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-exchange-alt mr-2"></i>
                        异常传递 vs 异常处理
                    </h4>
                    <p class="text-gray-700 mb-4">在编写代码时，通常有两种方式来处理异常：</p>
                    
                    <div class="grid md:grid-cols-2 gap-6 mb-6">
                        <div class="border-l-4 border-indigo-500 pl-4">
                            <h5 class="font-semibold text-lg mb-2">异常传递</h5>
                            <p class="text-gray-700 mb-3">对于一些无法在当前方法中有效处理的异常，应该通过<code class="bg-gray-100 px-1 rounded">throws</code>关键字将异常抛出，交给上层调用者进行处理。</p>
                            <div class="code-block">
                                <pre><code class="language-java">public void readFile(String filePath) throws IOException {
    FileReader fileReader = new FileReader(filePath);
    // 可能会抛出IOException
}</code></pre>
                            </div>
                        </div>
                        <div class="border-l-4 border-indigo-500 pl-4">
                            <h5 class="font-semibold text-lg mb-2">异常处理</h5>
                            <p class="text-gray-700 mb-3">如果能够在方法内对异常进行有效的处理，可以通过<code class="bg-gray-100 px-1 rounded">try-catch</code>进行捕获和处理。</p>
                            <div class="code-block">
                                <pre><code class="language-java">public void readFile(String filePath) {
    try {
        FileReader fileReader = new FileReader(filePath);
    } catch (IOException e) {
        System.err.println("读取文件失败：" + e.getMessage());
        // 其他异常处理逻辑
    }
}</code></pre>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Custom Exception -->
                <div class="bg-white rounded-xl p-6 card-shadow">
                    <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-pencil-ruler mr-2"></i>
                        定制化异常处理
                    </h4>
                    <p class="text-gray-700 mb-4">
                        在复杂的系统中，我们可能会定义自定义异常类来对错误进行更细粒度的分类。自定义异常类继承<code class="bg-gray-100 px-1 rounded">Exception</code>或<code class="bg-gray-100 px-1 rounded">RuntimeException</code>，并根据需要增加附加的信息。
                    </p>
                    <div class="code-block mb-4">
                        <pre><code class="language-java">public class DatabaseException extends Exception {
    public DatabaseException(String message) {
        super(message);
    }
}

public class NetworkException extends Exception {
    public NetworkException(String message) {
        super(message);
    }
}</code></pre>
                    </div>
                    <p class="text-gray-700 mb-4">
                        在这种情况下，捕获时可以根据具体的异常类型进行不同的处理：
                    </p>
                    <div class="code-block">
                        <pre><code class="language-java">try {
    // 业务逻辑
} catch (DatabaseException e) {
    // 数据库相关的异常处理
} catch (NetworkException e) {
    // 网络相关的异常处理
}</code></pre>
                    </div>
                </div>
            </article>
        </section>

        <!-- Callback Mechanism -->
        <section id="callback" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="bg-indigo-600 w-2 h-8 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold text-gray-800">回调机制</h2>
            </div>

            <!-- Basic Concepts -->
            <article class="mb-12">
                <h3 class="text-2xl font-semibold text-gray-800 mb-6 flex items-center">
                    <i class="fas fa-comments text-indigo-500 mr-3"></i>
                    回调的基本概念
                </h3>

                <div class="bg-white rounded-xl p-6 card-shadow mb-8">
                    <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-question-circle mr-2"></i>
                        什么是回调？
                    </h4>
                    <p class="text-gray-700">
                        回调是一种设计模式，用于允许函数参数化地传递某种功能，或者是某个操作完成后，通过某个函数回调通知。回调机制使得系统能够根据外部事件的发生，执行特定的操作。
                    </p>
                    <p class="text-gray-700 mt-3">
                        在Java中，回调通常通过接口或抽象类来实现。通过传递回调函数，可以灵活地执行某些特定操作。
                    </p>
                </div>

                <!-- Callback Implementation -->
                <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                    <i class="fas fa-code mr-2"></i>
                    回调的实现方式
                </h4>

                <div class="grid md:grid-cols-2 gap-8 mb-8">
                    <!-- Traditional Callback -->
                    <div class="bg-white rounded-xl p-6 card-shadow hover-scale">
                        <h5 class="font-semibold text-lg mb-3 text-indigo-700 flex items-center">
                            <i class="fas fa-arrow-turn-down mr-2"></i>
                            传统的回调方式：接口
                        </h5>
                        <p class="text-gray-700 mb-4">
                            最常见的回调方式是通过接口来实现。当某个操作完成时，会调用回调接口的<code class="bg-gray-100 px-1 rounded">callback</code>方法，通知调用者操作完成。
                        </p>
                        <div class="code-block">
                            <pre><code class="language-java">interface TaskCallback {
    void onSuccess(String result);
    void onFailure(Exception e);
}

public class Task {
    public void executeTask(TaskCallback callback) {
        try {
            // 执行任务
            String result = "任务完成";
            callback.onSuccess(result);
        } catch (Exception e) {
            callback.onFailure(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Task task = new Task();
        task.executeTask(new TaskCallback() {
            @Override
            public void onSuccess(String result) {
                System.out.println("成功：" + result);
            }

            @Override
            public void onFailure(Exception e) {
                System.out.println("失败：" + e.getMessage());
            }
        });
    }
}</code></pre>
                        </div>
                    </div>

                    <!-- Lambda Callback -->
                    <div class="bg-white rounded-xl p-6 card-shadow hover-scale">
                        <h5 class="font-semibold text-lg mb-3 text-indigo-700 flex items-center">
                            <i class="fab fa-java mr-2"></i>
                            使用Lambda表达式简化回调
                        </h5>
                        <p class="text-gray-700 mb-4">
                            Java 8引入了Lambda表达式，使得回调的实现更加简洁。通过Lambda，我们可以在传递回调时使用更加简洁的代码。
                        </p>
                        <div class="code-block">
                            <pre><code class="language-java">public class Task {
    public void executeTask(Consumer<String> successCallback, 
                          Consumer<Exception> failureCallback) {
        try {
            // 执行任务
            String result = "任务完成";
            successCallback.accept(result);
        } catch (Exception e) {
            failureCallback.accept(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Task task = new Task();
        task.executeTask(
            result -> System.out.println("成功：" + result),
            e -> System.out.println("失败：" + e.getMessage())
        );
    }
}</code></pre>
                        </div>
                    </div>
                </div>
            </article>

            <!-- Exception with Callback -->
            <article class="mb-12">
                <h3 class="text-2xl font-semibold text-gray-800 mb-6 flex items-center">
                    <i class="fas fa-link text-indigo-500 mr-3"></i>
                    异常与回调结合使用
                </h3>

                <div class="grid md:grid-cols-2 gap-8">
                    <!-- Exception in Callback -->
                    <div class="bg-white rounded-xl p-6 card-shadow hover-scale">
                        <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                            <i class="fas fa-exclamation-triangle mr-2"></i>
                            异常处理中的回调机制
                        </h4>
                        <p class="text-gray-700 mb-4">
                            在复杂的业务场景中，可能需要在回调函数中处理异常，确保在任务完成时能够优雅地处理错误。
                        </p>
                        <div class="code-block">
                            <pre><code class="language-java">interface Callback {
    void onComplete(String result);
    void onError(Exception e);
}

public class Task {
    public void execute(Callback callback) {
        try {
            // 执行任务
            String result = "任务成功";
            callback.onComplete(result);
        } catch (Exception e) {
            callback.onError(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Task task = new Task();
        task.execute(new Callback() {
            @Override
            public void onComplete(String result) {
                System.out.println("任务完成：" + result);
            }

            @Override
            public void onError(Exception e) {
                System.out.println("发生错误：" + e.getMessage());
            }
        });
    }
}</code></pre>
                        </div>
                    </div>

                    <!-- CompletableFuture -->
                    <div class="bg-white rounded-xl p-6 card-shadow hover-scale">
                        <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                            <i class="fas fa-bolt mr-2"></i>
                            异常处理中的回调增强：<code class="bg-gray-100 px-1 rounded">CompletableFuture</code>
                        </h4>
                        <p class="text-gray-700 mb-4">
                            Java 8的<code class="bg-gray-100 px-1 rounded">CompletableFuture</code>不仅支持异步编程，还支持在任务完成时进行异常处理。<code class="bg-gray-100 px-1 rounded">CompletableFuture</code>提供了<code class="bg-gray-100 px-1 rounded">handle</code>方法，允许在异步操作完成时处理结果或异常。
                        </p>
                        <div class="code-block">
                            <pre><code class="language-java">CompletableFuture.supplyAsync(() -> {
    // 模拟任务执行
    if (Math.random() > 0.5) {
        throw new RuntimeException("模拟异常");
    }
    return "任务成功";
}).handle((result, ex) -> {
    if (ex != null) {
        System.out.println("任务失败：" + ex.getMessage());
    } else {
        System.out.println("任务成功：" + result);
    }
    return null;
});</code></pre>
                        </div>
                    </div>
                </div>
            </article>

            <!-- Best Practices -->
            <article>
                <h3 class="text-2xl font-semibold text-gray-800 mb-6 flex items-center">
                    <i class="fas fa-medal text-indigo-500 mr-3"></i>
                    优雅的异常与回调设计实践
                </h3>

                <div class="grid md:grid-cols-2 gap-8">
                    <!-- Exception Wrapping -->
                    <div class="bg-white rounded-xl p-6 card-shadow hover-scale">
                        <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                            <i class="fas fa-box mr-2"></i>
                            异常的封装与转换
                        </h4>
                        <p class="text-gray-700 mb-4">
                            在实际的开发中，我们应该尽量避免在高层业务逻辑中暴露底层异常，而是将底层的异常封装并转化为自定义异常，提供给上层进行处理。
                        </p>
                        <div class="code-block">
                            <pre><code class="language-java">public class DatabaseService {
    public void queryDatabase() throws DatabaseException {
        try {
            // 数据库操作
        } catch (SQLException e) {
            throw new DatabaseException("数据库查询失败", e);
        }
    }
}</code></pre>
                        </div>
                    </div>

                    <!-- Callback Decoupling -->
                    <div class="bg-white rounded-xl p-6 card-shadow hover-scale">
                        <h4 class="text-xl font-semibold mb-4 text-indigo-700 flex items-center">
                            <i class="fas fa-project-diagram mr-2"></i>
                            回调的解耦
                        </h4>
                        <p class="text-gray-700 mb-4">
                            为了提高回调的可维护性，建议将回调的逻辑和实际执行的操作解耦。可以使用<strong>观察者模式</strong>或<strong>事件驱动架构</strong>，将回调的实现与业务逻辑分离，使代码更加灵活和可扩展。
                        </p>
                        <div class="code-block">
                            <pre><code class="language-java">interface EventListener {
    void onEvent(String message);
}

class EventPublisher {
    private final List<EventListener> listeners = new ArrayList<>();

    public void addListener(EventListener listener) {
        listeners.add(listener);
    }

    public void publish(String message) {
        for (EventListener listener : listeners) {
            listener.onEvent(message);
        }
    }
}</code></pre>
                        </div>
                    </div>
                </div>
            </article>
        </section>

        <!-- Visualization -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="bg-indigo-600 w-2 h-8 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold text-gray-800">概念关系图</h2>
            </div>

            <div class="bg-white rounded-xl p-6 card-shadow">
                <div class="mermaid">
                    graph TD
                    A[Java异常与回调机制] --> B[异常处理]
                    A --> C[回调机制]
                    
                    B --> B1[异常分类]
                    B1 --> B11[受检查异常]
                    B1 --> B12[未受检查异常]
                    B --> B2[处理方式]
                    B2 --> B21[try-catch-finally]
                    B2 --> B22[throws关键字]
                    B --> B3[最佳实践]
                    B3 --> B31[自定义异常]
                    B3 --> B32[异常封装]
                    
                    C --> C1[实现方式]
                    C1 --> C11[接口回调]
                    C1 --> C12[Lambda表达式]
                    C --> C2[应用场景]
                    C2 --> C21[异步编程]
                    C2 --> C22[事件处理]
                    C --> C3[最佳实践]
                    C3 --> C31[CompletableFuture]
                    C3 --> C32[观察者模式]
                    
                    A --> D[组合应用]
                    D --> D1[回调中的异常处理]
                    D --> D2[异步异常处理]
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-8">
        <div class="max-w-5xl mx-auto px-4">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-semibold text-white mb-2">技术小馆</h3>
                    <p class="text-gray-400">探索编程艺术的殿堂</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-indigo-400 hover:text-indigo-300 transition-colors duration-200">
                        <i class="fas fa-globe mr-2"></i>http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-6 pt-6 text-center text-sm text-gray-500">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'dark',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```